﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdAveMaterial : OdRxObject
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdAveMaterial(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdAveMaterial_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdAveMaterial obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdAveMaterial()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdAveMaterial(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public new static OdAveMaterial cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdAveMaterial_cast(OdRxObject.getCPtr(pObj));
			OdAveMaterial result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdAveMaterial_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdAveMaterial_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdAveMaterial_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdAveMaterial createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdAveMaterial_createObject();
			OdAveMaterial result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdAveMaterial getMaterial(OdDbObjectId blockRefId)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdAveMaterial_getMaterial(OdDbObjectId.getCPtr(blockRefId));
			OdAveMaterial result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdAveMaterial)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static string getMaterialName(OdDbObjectId blockRefId)
		{
			string result = TD_DbPINVOKE.OdAveMaterial_getMaterialName(OdDbObjectId.getCPtr(blockRefId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResult writeMaterial(OdDbDatabase pDb, OdDbHandle holderHandle)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdAveMaterial_writeMaterial__SWIG_0(this.swigCPtr, OdDbDatabase.getCPtr(pDb), OdDbHandle.getCPtr(holderHandle));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResult writeMaterial(OdDbDatabase pDb)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdAveMaterial_writeMaterial__SWIG_1(this.swigCPtr, OdDbDatabase.getCPtr(pDb));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResult writeMaterial()
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdAveMaterial_writeMaterial__SWIG_2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool attachToObject(OdDbObjectId entityId)
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_attachToObject(this.swigCPtr, OdDbObjectId.getCPtr(entityId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool attachToLayer(OdDbObjectId layerId)
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_attachToLayer(this.swigCPtr, OdDbObjectId.getCPtr(layerId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool attachToACI(ushort colorIndex)
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_attachToACI(this.swigCPtr, colorIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void detachFromObject(OdDbObjectId entityId)
		{
			TD_DbPINVOKE.OdAveMaterial_detachFromObject(OdDbObjectId.getCPtr(entityId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void detachFromLayer(OdDbObjectId layerId)
		{
			TD_DbPINVOKE.OdAveMaterial_detachFromLayer(OdDbObjectId.getCPtr(layerId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static void detachFromACI(OdDbDatabase pDb, ushort colorIndex)
		{
			TD_DbPINVOKE.OdAveMaterial_detachFromACI(OdDbDatabase.getCPtr(pDb), colorIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static bool getAttachedMaterial(OdDbObjectId sourceId, OdDbObjectId blockRefId)
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_getAttachedMaterial__SWIG_0(OdDbObjectId.getCPtr(sourceId), OdDbObjectId.getCPtr(blockRefId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static bool getAttachedMaterial(OdDbDatabase pDb, ushort colorIndex, OdDbObjectId blockRefId)
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_getAttachedMaterial__SWIG_1(OdDbDatabase.getCPtr(pDb), colorIndex, OdDbObjectId.getCPtr(blockRefId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static void getAciMaterialMap(OdDbDatabase pDb, OdDbObjectIdArray blockRefIds)
		{
			TD_DbPINVOKE.OdAveMaterial_getAciMaterialMap(OdDbDatabase.getCPtr(pDb), OdDbObjectIdArray.getCPtr(blockRefIds));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual MaterialType type()
		{
			MaterialType result = (MaterialType)TD_DbPINVOKE.OdAveMaterial_type(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isAttribUsed(MaterialAttrib attributes)
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_isAttribUsed(this.swigCPtr, (int)attributes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string name()
		{
			string result = TD_DbPINVOKE.OdAveMaterial_name(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string description()
		{
			string result = TD_DbPINVOKE.OdAveMaterial_description(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setName(string name)
		{
			TD_DbPINVOKE.OdAveMaterial_setName(this.swigCPtr, name);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDescription(string description)
		{
			TD_DbPINVOKE.OdAveMaterial_setDescription(this.swigCPtr, description);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double ambientFactor()
		{
			double result = TD_DbPINVOKE.OdAveMaterial_ambientFactor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public uint ambientColor()
		{
			uint result = TD_DbPINVOKE.OdAveMaterial_ambientColor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool ambientColorCurrent()
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_ambientColorCurrent(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool ambientLock()
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_ambientLock(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setAmbientFactor(double ambientFactor)
		{
			TD_DbPINVOKE.OdAveMaterial_setAmbientFactor(this.swigCPtr, ambientFactor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setAmbientColor(uint ambientColor)
		{
			TD_DbPINVOKE.OdAveMaterial_setAmbientColor(this.swigCPtr, ambientColor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setAmbientColorCurrent(bool currentColor)
		{
			TD_DbPINVOKE.OdAveMaterial_setAmbientColorCurrent(this.swigCPtr, currentColor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setAmbientLock(bool ambientLock)
		{
			TD_DbPINVOKE.OdAveMaterial_setAmbientLock(this.swigCPtr, ambientLock);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double diffuseFactor()
		{
			double result = TD_DbPINVOKE.OdAveMaterial_diffuseFactor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public uint diffuseColor()
		{
			uint result = TD_DbPINVOKE.OdAveMaterial_diffuseColor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool diffuseColorCurrent()
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_diffuseColorCurrent(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdAveBitmap diffuseBitmap()
		{
			OdAveBitmap result = new OdAveBitmap(TD_DbPINVOKE.OdAveMaterial_diffuseBitmap(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDiffuseFactor(double diffuseFactor)
		{
			TD_DbPINVOKE.OdAveMaterial_setDiffuseFactor(this.swigCPtr, diffuseFactor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDiffuseColor(uint diffuseColor)
		{
			TD_DbPINVOKE.OdAveMaterial_setDiffuseColor(this.swigCPtr, diffuseColor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDiffuseColorCurrent(bool currentColor)
		{
			TD_DbPINVOKE.OdAveMaterial_setDiffuseColorCurrent(this.swigCPtr, currentColor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double specularFactor()
		{
			double result = TD_DbPINVOKE.OdAveMaterial_specularFactor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public uint specularColor()
		{
			uint result = TD_DbPINVOKE.OdAveMaterial_specularColor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool specularColorCurrent()
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_specularColorCurrent(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool specularMirror()
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_specularMirror(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool specularLock()
		{
			bool result = TD_DbPINVOKE.OdAveMaterial_specularLock(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdAveBitmap specularBitmap()
		{
			OdAveBitmap result = new OdAveBitmap(TD_DbPINVOKE.OdAveMaterial_specularBitmap__SWIG_0(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSpecularFactor(double specularFactor)
		{
			TD_DbPINVOKE.OdAveMaterial_setSpecularFactor(this.swigCPtr, specularFactor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setSpecularColor(uint specularColor)
		{
			TD_DbPINVOKE.OdAveMaterial_setSpecularColor(this.swigCPtr, specularColor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setSpecularMirror(bool mirror)
		{
			TD_DbPINVOKE.OdAveMaterial_setSpecularMirror(this.swigCPtr, mirror);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setSpecularLock(bool specularLock)
		{
			TD_DbPINVOKE.OdAveMaterial_setSpecularLock(this.swigCPtr, specularLock);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double roughness()
		{
			double result = TD_DbPINVOKE.OdAveMaterial_roughness(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setRoughness(double arg0)
		{
			TD_DbPINVOKE.OdAveMaterial_setRoughness(this.swigCPtr, arg0);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double transparency()
		{
			double result = TD_DbPINVOKE.OdAveMaterial_transparency(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdAveBitmap transparencyBitmap()
		{
			OdAveBitmap result = new OdAveBitmap(TD_DbPINVOKE.OdAveMaterial_transparencyBitmap(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTransparency(double transparency)
		{
			TD_DbPINVOKE.OdAveMaterial_setTransparency(this.swigCPtr, transparency);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double refraction()
		{
			double result = TD_DbPINVOKE.OdAveMaterial_refraction(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setRefraction(double refraction)
		{
			TD_DbPINVOKE.OdAveMaterial_setRefraction(this.swigCPtr, refraction);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdAveBitmap bumpMap()
		{
			OdAveBitmap result = new OdAveBitmap(TD_DbPINVOKE.OdAveMaterial_bumpMap__SWIG_0(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId holderId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdAveMaterial_holderId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string handleDbMaterial()
		{
			string result = TD_DbPINVOKE.OdAveMaterial_handleDbMaterial(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setHandleDbMaterial(string sDesc)
		{
			TD_DbPINVOKE.OdAveMaterial_setHandleDbMaterial(this.swigCPtr, sDesc);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		private object locker = new object();

		private HandleRef swigCPtr;
	}
}
